Apple WWDC 1996/WWDC96_1996 (CD).toast/Technology Materials/MacOS 8 Resources/Developer Tools/Mac OS 8 Interfaces & Libraries/Interfaces/PInterfaces/NameRegistry.p

Text File | 1996-05-01 | 27.7 KB | 712 lines | [TEXT/MPS ]

{
     File:        NameRegistry.p

     Contains:    NameRegistry Interfaces

     Version:    Technology:    System 8
                 Release:    Universal Interfaces 3.0d3 on Copland DR1

     Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.

     Bugs?:        If you find a problem with this file, send the file and version
                 information (from above) and the problem description to:

                     Internet:    [e-mail]
                     AppleLink:    APPLE.BUGS

}
{$IFC UNDEFINED UsingIncludes}
{$SETC UsingIncludes := 0}
{$ENDC}

{$IFC NOT UsingIncludes}
 UNIT NameRegistry;
 INTERFACE
{$ENDC}

{$IFC UNDEFINED __NAMEREGISTRY__}
{$SETC __NAMEREGISTRY__ := 1}

{$I+}
{$SETC NameRegistryIncludes := UsingIncludes}
{$SETC UsingIncludes := 1}

{$IFC UNDEFINED __TYPES__}
{$I Types.p}
{$ENDC}

{$PUSH}
{$ALIGN POWER}
{$LibExport+}

{$IFC FOR_SYSTEM7_AND_SYSTEM8_PREEMPTIVE }
{
 These definitions apply to both the System7 and System8 interfaces
 RegEntryRef:    The Global Entry Reference
}

TYPE
    RegEntryRefPtr = ^RegEntryRef;
    RegEntryRef = RECORD
        contents:                ARRAY [0..3] OF UInt32;
    END;


CONST
    kRegPathNameSeparator        = 58;                            {  0x3A  }

    kRegMaxPropertyNameLength    = 31;                            {  Max length of Property Name (terminator not included)  }


TYPE
    RegPropertyNameBuf                    = PACKED ARRAY [0..31] OF CHAR;
{$ENDC}
{$IFC FOR_SYSTEM8_PREEMPTIVE }
{
------------------------------------------------------------------------------------
Name Registry Interface for System 8
------------------------------------------------------------------------------------
}
{
------------------------------------------------------------------------------------
 Foundation Types
------------------------------------------------------------------------------------
}
{  Entry Name Definitions (Entry Names are C-Strings) }

CONST
    kRegMaxEntryNameLength        = 47;                            {  Max length of a C-String Entry Name (terminator not included)  }

{  length of RegEntryNameBuf = kRegMaxEntryNameLength +1 }

TYPE
    RegEntryNameBuf                        = PACKED ARRAY [0..47] OF CHAR;
{  Create Entry Options }
    RegCreateEntryOptions                = OptionBits;
{  use "kNilOptions" for no options }

CONST
    kRegCreateResidentEntry        = $00000001;                    {  make entry resident  }

{  Delete Entry Options }

TYPE
    RegDeleteEntryOptions                = OptionBits;
{  use "kNilOptions" for no options }

CONST
    kRegDeleteEmbeddedEntries    = $00000001;                    {  delete embedded entries  }

{  Entry Iterator }

TYPE
    RegEntryIterator = ^LONGINT;
{  Entry Iterator Options }
    RegEntryIteratorOptions                = OptionBits;
{  use "kNilOptions" for no options }

CONST
    kRegIterateEmbeddedEntries    = $00000002;                    {  iterate embedded entries  }

{
 Property Instances
 An instance value for a property is assigned by the Name Registry when the
 instance is created.  This value is used to distinguish this instance from any
 other instances of the property.  Instance values are unique and persistent for
 the life of the property. Thus, clients can obtain a reference to a property (name
 and instance value) and use that reference until the property is deleted or the
 system is restarted.  At restart, new instance values are assigned to all
 properties, including any restored persistent properties.
}

TYPE
    RegPropertyInstance                    = UInt32;

CONST
    kRegNilPropertyInstance        = $00000000;                    {  nil property instance  }
    kRegAnyPropertyInstance        = $FFFFFFFF;                    {  any property instance  }
    kRegAllPropertyInstances    = $FFFFFFFE;                    {  all property instances  }

{  Create Property Options }

TYPE
    RegCreatePropertyOptions            = OptionBits;
{  use "kNilOptions" for no options }

CONST
    kRegMultiInstanceProperty    = $00000001;                    {  multiple-instance property  }

{  Property Iterator }

TYPE
    RegPropertyIterator = ^LONGINT;
{  Transaction Reference }
    RegTransaction = ^LONGINT;
{  Nil Transaction Reference }

CONST
    kRegNilTransaction            = 0;

{
------------------------------------------------------------------------------------
 Name Registry Calls
------------------------------------------------------------------------------------
}
{
------------------------------------------------------------------------------------
 EntryRef Handling
------------------------------------------------------------------------------------
}
{  Compare two EntryRef's for equality.  }
FUNCTION RegEntryRefIsEqual({CONST}VAR ref1: RegEntryRef; {CONST}VAR ref2: RegEntryRef): BOOLEAN; C;
{
------------------------------------------------------------------------------------
 Adding and Deleting Entries
------------------------------------------------------------------------------------
}
{
 Create an Entry
 If (parentEntry) is NULL, the path name is assumed to be an absolute path name
 rooted to the anonymous, unnamed root.
 Note, RegCreateEntry only creates a single entry, the one at the end of the path.
 Thus, all parent entries along the path to the new entry (ancestors) must already
 exist.
}
FUNCTION RegCreateEntry(transaction: RegTransaction; {CONST}VAR parentEntry: RegEntryRef; pathName: ConstCStringPtr; options: RegCreateEntryOptions; VAR newEntry: RegEntryRef): OSStatus; C;
{
 Delete an Entry or Subtree
 RegDeleteEntry can be used to delete a single entry or a complete subtree.
 To delete a subtree, set the RegDeleteEmbedded option.
 All properties for deleted entries are also deleted.
}
FUNCTION RegDeleteEntry(transaction: RegTransaction; {CONST}VAR ref: RegEntryRef; options: RegDeleteEntryOptions): OSStatus; C;
{
------------------------------------------------------------------------------------
 LookUp Entry by Name
------------------------------------------------------------------------------------
}
{
 Lookup Entry
 Locates an entry given a specified subroot (searchPointRef) and path name.  If the
 searchPointRef pointer is NULL, the path name is assumed to be an absolute path
 name rooted to the root of the Registry.
}
FUNCTION RegLookupEntry(transaction: RegTransaction; {CONST}VAR searchPointRef: RegEntryRef; pathName: ConstCStringPtr; VAR foundEntry: RegEntryRef): OSStatus; C;
{
------------------------------------------------------------------------------------
Get Entry Name and Parent
------------------------------------------------------------------------------------
}
{
 Retrieve the name component for the specified entry, and return the EntryRef for
 the parent entry.
}
FUNCTION RegGetEntryName(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; VAR parentEntry: RegEntryRef; nameComponent: CStringPtr): OSStatus; C;
{
------------------------------------------------------------------------------------
Get Path Name
------------------------------------------------------------------------------------
}
{
 These are utility routines to turn an Entry ID back into a name string.
 Get Entry Path Size
 Note, path size is returned in bytes for C-String paths
}
FUNCTION RegGetEntryPathSize(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; VAR pathSize: ByteCount): OSStatus; C;
{  Get Path Name }
FUNCTION RegGetEntryPath(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; pathName: CStringPtr; pathSize: ByteCount): OSStatus; C;
{
------------------------------------------------------------------------------------
 Entry Iteration
------------------------------------------------------------------------------------
}
{
 An Entry Iterator maintains three variables that are of interest to clients.
 First is an "OutermostScope" which defines the outer boundry of the iteration.
 This is defined by the starting entry and includes that entry plus all of it's
 embedded entries. Second is a "currentScope" which is the entry the iterator is
 currently in. And third is a "currentPosition" which is the last entry returned
 during an iteration.
 Create Entry Iterator
 Create the iterator structure. The outermostScope and currentScope of the iterator
 are set to "startEntry".  If "startEntry" = NULL, the outermostScope and
 currentScope are set to the root entry.  The currentPosition for the iterator is
 set to "nil".
 If propertyName != Null, propertyName, propertyValue, and propertySize are used
 to filter the entries returned during an iteration.  If propertyName == Null, all
 entries are returned.
}
FUNCTION RegCreateEntryIterator(transaction: RegTransaction; {CONST}VAR startEntry: RegEntryRef; options: RegEntryIteratorOptions; propertyName: ConstCStringPtr; propertyValue: UNIV Ptr; propertySize: ByteCount; VAR iterator: RegEntryIterator): OSStatus; C;
{  Dispose Entry Iterator }
FUNCTION RegDisposeEntryIterator(iterator: RegEntryIterator): OSStatus; C;
{
 Enter Child Entry
 Move an Entry Iterator into the scope of a specified child entry.  The
 currentScope of the iterator is set to the entry specified in "childEntry".  If
 "childEntry" is nil, the currentScope is set to the entry specified by the
 currentPosition of the iterator.
 Note RegEnterEntry cannot be used if the "kRegIterateEmbeddedEntries" option was
 set when the iterator was created.
}
FUNCTION RegEnterEntry(transaction: RegTransaction; iterator: RegEntryIterator; VAR childEntry: RegEntryRef): OSStatus; C;
{
 Exit to Parent Entry
 Move an Entry Iterator out of the current entry back into the scope of it's parent
 entry. The currentPosition of the iterator is reset to the current entry (the
 previous currentScope), so the next iteration call will continue where it left off.
 This position is returned in parameter "currentPosition".
 Note RegExitEntry cannot be used if the "kRegIterateEmbeddedEntries" option was
 set when the iterator was created.
}
FUNCTION RegExitEntry(transaction: RegTransaction; iterator: RegEntryIterator; VAR currentPosition: RegEntryRef): OSStatus; C;
{
 Iterate Entries
 Iterate and return entries contained within the entry defined by the current
 scope of the iterator. If kRegIterateEmbeddedEntries option was specified when the
 iterator was created, all embedded entries will be included in the iteration.  If a
 property selection (name , value, and size) was specified when the iterator was
 created, the only entries having a matching property are returned.  Entries are
 returned one at a time. When OSStatus == nrIterationDone, all entries have been exhausted, and the
 value of nextEntry will be Nil. If changed == true, one or more changes (entry
 create or delete) occured since the last interation call.
}
FUNCTION RegIterateEntries(transaction: RegTransaction; iterator: RegEntryIterator; VAR nextEntry: RegEntryRef; VAR changed: BOOLEAN): OSStatus; C;
{
 Restart Entry Iteration
 Restart an iteration within the current scope.  The iterator is reset such that
 iteration of the contents of the currentScope entry can be restarted. The
 outermostScope and currentScope of the iterator are unchanged. The currentPosition
 for the iterator is set to "nil".
}
FUNCTION RegRestartEntryIteration(iterator: RegEntryIterator): OSStatus; C;
{
------------------------------------------------------------------------------------
 Adding and Deleting Properties
------------------------------------------------------------------------------------
}
{
 Create Property
 A  single instance property is created by default. To create a multiple-instance
 property set the kRegMultiInstanceProperty option. The next instance of the
 property will be created and the instance value will be returned in
 propertyInstance.
}
FUNCTION RegCreateProperty(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; propertyName: ConstCStringPtr; propertyValue: UNIV Ptr; propertySize: ByteCount; options: RegCreatePropertyOptions; VAR propertyInstance: RegPropertyInstance): OSStatus; C;
{
 Delete Property
 To delete a property the desired property instance(s) must be explicitly
 identified. To delete a single instance property set propertyInstance to
 kRegNilPropertyInstance.  To delete all instances of a multi-instance property, set
 propertyInstance to kRegAllPropertyInstances.  Otherwise, propertyInstance must
 be set to a valid instance value.
}
FUNCTION RegDeleteProperty(transaction: RegTransaction; {CONST}VAR EntryRef: RegEntryRef; propertyName: ConstCStringPtr; propertyInstance: RegPropertyInstance): OSStatus; C;
{
------------------------------------------------------------------------------------
 Get/Set Property Values
------------------------------------------------------------------------------------
}
{
 Get/Set the value of the specified property for the specified entry.  To get, get
 size, and set property values the desired property instance must be explicitly
 identified.  For single instance properites propertyInstance must  be set to
 kRegNilPropertyInstance.  Otherwise, propertyInstance must be set to a valid
 instance value.
 Get Property size
}
FUNCTION RegGetPropertySize(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; propertyName: ConstCStringPtr; propertyInstance: RegPropertyInstance; VAR propertySize: ByteCount): OSStatus; C;
{  Get Property }
FUNCTION RegGetProperty(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; propertyName: ConstCStringPtr; propertyInstance: RegPropertyInstance; propertyValue: UNIV Ptr; VAR propertySize: ByteCount): OSStatus; C;
{  Set Property }
FUNCTION RegSetProperty(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; propertyName: ConstCStringPtr; propertyInstance: RegPropertyInstance; propertyValue: UNIV Ptr; propertySize: ByteCount): OSStatus; C;
{
------------------------------------------------------------------------------------
 Iterating Properties
------------------------------------------------------------------------------------
}
{
 Create Property Iterator
 Create the property iterator structure. The target entry is defined by entryRef.
 If a propertyName is specified, only property instances having the specified name
 are returned. If propertyName == nil, all properties are returned.
}
FUNCTION RegCreatePropertyIterator(transaction: RegTransaction; {CONST}VAR entryRef: RegEntryRef; propertyName: ConstCStringPtr; VAR iterator: RegPropertyIterator): OSStatus; C;
{  Dispose Property Iterator }
FUNCTION RegDisposePropertyIterator(iterator: RegPropertyIterator): OSStatus; C;
{
 Iterate Properites
 Iterate and return properties for given entry.  If a propertyName was specified
 when the iterator was created, then only property instances for that name are
 returned. Otherwise, all properties are returned.  The return value in
 propertyInstance will be kRegNilPropertyInstance if the property is single
 instance.  Else it will contain the instance value for the property. If
 changed == true, one or more changes (property creates or deletes) occured since the
 last iterate call.  When OSStatus == nrIterationDone, all properties have been exhausted.
}
FUNCTION RegIterateProperties(transaction: RegTransaction; iterator: RegPropertyIterator; foundProperty: CStringPtr; VAR propertyInstance: RegPropertyInstance; VAR changed: BOOLEAN): OSStatus; C;
{
 Restart Property Iteration
 Used to re-iterate over a list of properties.  The Property Iterator is reset to
 the beginning of the list of properties for an entry.
}
FUNCTION RegRestartPropertyIteration(iterator: RegPropertyIterator): OSStatus; C;
{
------------------------------------------------------------------------------------
 Transaction-control calls
------------------------------------------------------------------------------------
}
{
 Begin Transaction
 Marks the beginning of a sequence of Name Registry calls that compose a Registry
 transaction.  An internal data structure for the transaction is created and a
 reference to the transaction is returned in "tranasaction". This reference must be
 used with all subsequence Name Registry calls pertaining to the transaction. The
 transaction reference must be disposed using a RegCommitTransaction or
 RegAbortTranscation call.
}
FUNCTION RegBeginTransaction(VAR transaction: RegTransaction): OSStatus; C;
{
 Commit Transaction
 Commits the changes made to the registry for a sepecified transaction. All changes
 (entry create/delete, property create/delete, and  property value update) made for
 the transaction are atomically integrated into the Registry.  If result ==
 nrTransactionAborted, there was a conflict with changes from some other transaction,
 and this transaction was aborted, i.e., no changes for this transaction were made.
 In this case the transaction should be repeated.
 Note that RegCommitTransaction always disposes the transcation reference
 independant of the outcome of the transaction.  So to repeat a transaaction you
 must start over with a RegBeginTransaction call.
}
FUNCTION RegCommitTransaction(transaction: RegTransaction): OSStatus; C;
{
 Abort Transaction
 Aborts the changes made to the registry for a sepecified transaction. All changes
 (entry create/delete, property create/delete, and  property value update) made for
 the transaction are disgarded.
 RegAbortTransaction also disposes of the transcation reference.
}
FUNCTION RegAbortTransaction(transaction: RegTransaction): OSStatus; C;
{$ENDC}
{$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
{
------------------------------------------------------------------------------------
    Name Registry Interface for PowerSurge 1.0.2
------------------------------------------------------------------------------------
}
{
 * Name Registry - API for device driver name registration
 *
 * This interface provides access to the namespace used
 * by device drivers.  The data structures and entry points
 * are specialized and simplified for device driver use.
}
{
 //////////////////////////////////////////////////////////////////////////////
//
// Data Structures
//
}
{
 //////////////////////////////////////////////////////////////////////////////
//
// Foundation Types
//
}
{  Value of a property  }

TYPE
    RegPropertyValue                    = Ptr;
{  Length of property value  }
    RegPropertyValueSize                = UInt32;
{
 //////////////////////////////////////////////////////////////////////////////
//
// RegEntryID    :    The Global x-Namespace Entry Identifier
//
}
{  RegEntryID:    The Global Entry ID }
    RegEntryID                            = RegEntryRef;
    RegEntryIDPtr                         = ^RegEntryID;
{
 //////////////////////////////////////////////////////////////////////////////
//
// Root Entry Name Definitions    (Applies to all Names in the RootNameSpace)
//
//    * Names are a colon-separated list of name components.  Name components
//      may not themselves contain colons.
//    * Names are presented as null-terminated ASCII character strings.
//    * Names follow similar parsing rules to Apple file system absolute
//      and relative paths.  However the '::' parent directory syntax is
//      not currently supported.
}
{  Max length of Entry Name  }

CONST
    kRegCStrMaxEntryNameLength    = 47;

{  Entry Names are single byte ASCII  }

TYPE
    RegCStrEntryName                    = CHAR;
    RegCStrEntryNamePtr                    = ^CHAR;
{  length of RegCStrEntryNameBuf =  kRegCStrMaxEntryNameLength+1 }
    RegCStrEntryNameBuf                    = PACKED ARRAY [0..47] OF CHAR;
    RegCStrPathName                        = CHAR;
    RegPathNameSize                        = UInt32;

CONST
    kRegEntryNameTerminator        = $00;                            {  '\0'  }
    kRegPathNameTerminator        = $00;                            {  '\0'  }

{
 //////////////////////////////////////////////////////////////////////////////
//
// Property Name and ID Definitions
//    (Applies to all Properties Regardless of NameSpace)
}
    kRegMaximumPropertyNameLength = 31;                            {  Max length of Property Name  }
    kRegPropertyNameTerminator    = $00;                            {  '\0'  }


TYPE
    RegPropertyName                        = CHAR;
    RegPropertyNamePtr                    = ^CHAR;
{
 //////////////////////////////////////////////////////////////////////////////
//
// Iteration Operations
//
//    These specify direction when traversing the name relationships
}
    RegIterationOp                        = UInt32;
    RegEntryIterationOp                    = RegIterationOp;

CONST
                                                                {  Absolute locations }
    kRegIterRoot                = $00000002;                    {  "Upward" Relationships     }
    kRegIterParents                = $00000003;                    {  include all  parent(s) of entry  }
                                                                {  "Downward" Relationships }
    kRegIterChildren            = $00000004;                    {  include all children  }
    kRegIterSubTrees            = $00000005;                    {  include all sub trees of entry  }
    kRegIterDescendants            = $00000005;                    {  include all descendants of entry  }
                                                                {  "Horizontal" Relationships     }
    kRegIterSibling                = $00000006;                    {  include all siblings  }
                                                                {  Keep doing the same thing }
    kRegIterContinue            = $00000001;

{
 //////////////////////////////////////////////////////////////////////////////
//
// Name Entry and Property Modifiers
//

//
// Modifiers describe special characteristics of names
// and properties.  Modifiers might be supported for
// some names and not others.
//
// Device Drivers should not rely on functionality
// specified as a modifier.
}

TYPE
    RegModifiers                        = UInt32;
    RegEntryModifiers                    = RegModifiers;
    RegPropertyModifiers                = RegModifiers;

CONST
    kRegNoModifiers                = $00000000;                    {  no entry modifiers in place  }
    kRegUniversalModifierMask    = $0000FFFF;                    {  mods to all entries  }
    kRegNameSpaceModifierMask    = $00FF0000;                    {  mods to all entries within namespace  }
    kRegModifierMask            = $FF000000;                    {  mods to just this entry  }

{  Universal Property Modifiers  }
    kRegPropertyValueIsSavedToNVRAM = $00000020;                {  property is non-volatile (saved in NVRAM)  }
    kRegPropertyValueIsSavedToDisk = $00000040;                    {  property is non-volatile (saved on disk)  }

{
 ///////////////////////
//
// The Registry API
//
///////////////////////
}
{
 ///////////////////////
//
// Entry Management
//
///////////////////////
}
{
-------------------------------
 * EntryID handling
}
{
 * Initialize an EntryID to a known invalid state
 *   note: invalid != uninitialized
}
FUNCTION RegistryEntryIDInit(VAR id: RegEntryID): OSStatus; C;
{
 * Compare EntryID's for equality or if invalid
 *
 * If a NULL value is given for either id1 or id2, the other id
 * is compared with an invalid ID.  If both are NULL, the id's
 * are consided equal (result = true).
}
FUNCTION RegistryEntryIDCompare({CONST}VAR id1: RegEntryID; {CONST}VAR id2: RegEntryID): BOOLEAN; C;
{
 * Copy an EntryID
}
FUNCTION RegistryEntryIDCopy({CONST}VAR src: RegEntryID; VAR dst: RegEntryID): OSStatus; C;
{
 * Free an ID so it can be reused.
}
FUNCTION RegistryEntryIDDispose(VAR id: RegEntryID): OSStatus; C;
{
-------------------------------
 * Adding and removing entries
 *
 * If (parentEntry) is NULL, the name is assumed
 * to be a rooted path. It is rooted to an anonymous, unnamed root.
}
FUNCTION RegistryCStrEntryCreate({CONST}VAR parentEntry: RegEntryID; {CONST}VAR name: RegCStrPathName; VAR newEntry: RegEntryID): OSStatus; C;
FUNCTION RegistryEntryDelete({CONST}VAR id: RegEntryID): OSStatus; C;

TYPE
    RegEntryIter = ^LONGINT;
{
 * create/dispose the iterator structure
 *   defaults to root with relationship = kRegIterDescendants
}
FUNCTION RegistryEntryIterateCreate(VAR cookie: RegEntryIter): OSStatus; C;
FUNCTION RegistryEntryIterateDispose(VAR cookie: RegEntryIter): OSStatus; C;
{
 * set Entry Iterator to specified entry
}
FUNCTION RegistryEntryIterateSet(VAR cookie: RegEntryIter; {CONST}VAR startEntryID: RegEntryID): OSStatus; C;
{
 * Return each value of the iteration
 *
 * return entries related to the current entry
 * with the specified relationship
}
FUNCTION RegistryEntryIterate(VAR cookie: RegEntryIter; relationship: RegEntryIterationOp; VAR foundEntry: RegEntryID; VAR done: BOOLEAN): OSStatus; C;
{
 * return entries with the specified property
 *
 * A NULL RegPropertyValue pointer will return an
 * entry with the property containing any value.
}
FUNCTION RegistryEntrySearch(VAR cookie: RegEntryIter; relationship: RegEntryIterationOp; VAR foundEntry: RegEntryID; VAR done: BOOLEAN; {CONST}VAR propertyName: RegPropertyName; propertyValue: UNIV Ptr; propertySize: RegPropertyValueSize): OSStatus; C;
{
--------------------------------
 * Find a name in the namespace
 *
 * This is the fast lookup mechanism.
 * NOTE:  A reverse lookup mechanism
 *      has not been provided because
 *        some name services may not
 *        provide a fast, general reverse
 *        lookup.
}
FUNCTION RegistryCStrEntryLookup({CONST}VAR searchPointID: RegEntryID; {CONST}VAR pathName: RegCStrPathName; VAR foundEntry: RegEntryID): OSStatus; C;
{
---------------------------------------------
 * Convert an entry to a rooted name string
 *
 * A utility routine to turn an Entry ID
 * back into a name string.
}
FUNCTION RegistryEntryToPathSize({CONST}VAR entryID: RegEntryID; VAR pathSize: RegPathNameSize): OSStatus; C;
FUNCTION RegistryCStrEntryToPath({CONST}VAR entryID: RegEntryID; VAR pathName: RegCStrPathName; pathSize: RegPathNameSize): OSStatus; C;
{
 * Parse a path name.
 *
 * Retrieve the last component of the path, and
 * return a spec for the parent.
}
FUNCTION RegistryCStrEntryToName({CONST}VAR entryID: RegEntryID; VAR parentEntry: RegEntryID; VAR nameComponent: RegCStrEntryName; VAR done: BOOLEAN): OSStatus; C;
{
 //////////////////////////////////////////////////////
//
// Property Management
//
//////////////////////////////////////////////////////
}
{
-------------------------------
 * Adding and removing properties
}
FUNCTION RegistryPropertyCreate({CONST}VAR entryID: RegEntryID; {CONST}VAR propertyName: RegPropertyName; propertyValue: UNIV Ptr; propertySize: RegPropertyValueSize): OSStatus; C;
FUNCTION RegistryPropertyDelete({CONST}VAR entryID: RegEntryID; {CONST}VAR propertyName: RegPropertyName): OSStatus; C;
{
---------------------------
 * Traversing the Properties of a name
 *
}

TYPE
    RegPropertyIter = ^LONGINT;
FUNCTION RegistryPropertyIterateCreate({CONST}VAR entry: RegEntryID; VAR cookie: RegPropertyIter): OSStatus; C;
FUNCTION RegistryPropertyIterateDispose(VAR cookie: RegPropertyIter): OSStatus; C;
FUNCTION RegistryPropertyIterate(VAR cookie: RegPropertyIter; VAR foundProperty: RegPropertyName; VAR done: BOOLEAN): OSStatus; C;
{
 * Get the value of the specified property for the specified entry.
 *
}
FUNCTION RegistryPropertyGetSize({CONST}VAR entryID: RegEntryID; {CONST}VAR propertyName: RegPropertyName; VAR propertySize: RegPropertyValueSize): OSStatus; C;
{
 * (*propertySize) is the maximum size of the value returned in the buffer
 * pointed to by (propertyValue).  Upon return, (*propertySize) is the size of the
 * value returned.
}
FUNCTION RegistryPropertyGet({CONST}VAR entryID: RegEntryID; {CONST}VAR propertyName: RegPropertyName; propertyValue: UNIV Ptr; VAR propertySize: RegPropertyValueSize): OSStatus; C;
FUNCTION RegistryPropertySet({CONST}VAR entryID: RegEntryID; {CONST}VAR propertyName: RegPropertyName; propertyValue: UNIV Ptr; propertySize: RegPropertyValueSize): OSStatus; C;
{
 //////////////////////////////////////////////////////
//
// Modibute (err, I mean Modifier) Management
//
//////////////////////////////////////////////////////
}
{
 * Modifiers describe special characteristics of names
 * and properties.  Modifiers might be supported for
 * some names and not others.
 *
 * Device Drivers should not rely on functionality
 * specified as a modifier.  These interfaces
 * are for use in writing Experts.
}
{
 * Get and Set operators for entry modifiers
}
FUNCTION RegistryEntryGetMod({CONST}VAR entry: RegEntryID; VAR modifiers: RegEntryModifiers): OSStatus; C;
FUNCTION RegistryEntrySetMod({CONST}VAR entry: RegEntryID; modifiers: RegEntryModifiers): OSStatus; C;
{
 * Get and Set operators for property modifiers
}
FUNCTION RegistryPropertyGetMod({CONST}VAR entry: RegEntryID; {CONST}VAR name: RegPropertyName; VAR modifiers: RegPropertyModifiers): OSStatus; C;
FUNCTION RegistryPropertySetMod({CONST}VAR entry: RegEntryID; {CONST}VAR name: RegPropertyName; modifiers: RegPropertyModifiers): OSStatus; C;
{
 * Iterator operator for entry modifier search
}
FUNCTION RegistryEntryMod(VAR cookie: RegEntryIter; relationship: RegEntryIterationOp; VAR foundEntry: RegEntryID; VAR done: BOOLEAN; matchingModifiers: RegEntryModifiers): OSStatus; C;
{
 * Iterator operator for entries with matching
 * property modifiers
}
FUNCTION RegistryEntryPropertyMod(VAR cookie: RegEntryIter; relationship: RegEntryIterationOp; VAR foundEntry: RegEntryID; VAR done: BOOLEAN; matchingModifiers: RegPropertyModifiers): OSStatus; C;
{$ENDC}
{$ALIGN RESET}
{$POP}

{$SETC UsingIncludes := NameRegistryIncludes}

{$ENDC} {__NAMEREGISTRY__}

{$IFC NOT UsingIncludes}
 END.
{$ENDC}